home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.27-7 / scripts / checkpatch.pl < prev    next >
Encoding:
Perl Script  |  2008-10-09  |  61.8 KB  |  2,336 lines
  1. #!/usr/bin/perl -w
  2. # (c) 2001, Dave Jones. <davej@codemonkey.org.uk> (the file handling bit)
  3. # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
  4. # (c) 2007, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite, etc)
  5. # Licensed under the terms of the GNU GPL License version 2
  6.  
  7. use strict;
  8.  
  9. my $P = $0;
  10. $P =~ s@.*/@@g;
  11.  
  12. my $V = '0.21';
  13.  
  14. use Getopt::Long qw(:config no_auto_abbrev);
  15.  
  16. my $quiet = 0;
  17. my $tree = 1;
  18. my $chk_signoff = 1;
  19. my $chk_patch = 1;
  20. my $tst_only;
  21. my $emacs = 0;
  22. my $terse = 0;
  23. my $file = 0;
  24. my $check = 0;
  25. my $summary = 1;
  26. my $mailback = 0;
  27. my $summary_file = 0;
  28. my $root;
  29. my %debug;
  30. GetOptions(
  31.     'q|quiet+'    => \$quiet,
  32.     'tree!'        => \$tree,
  33.     'signoff!'    => \$chk_signoff,
  34.     'patch!'    => \$chk_patch,
  35.     'emacs!'    => \$emacs,
  36.     'terse!'    => \$terse,
  37.     'file!'        => \$file,
  38.     'subjective!'    => \$check,
  39.     'strict!'    => \$check,
  40.     'root=s'    => \$root,
  41.     'summary!'    => \$summary,
  42.     'mailback!'    => \$mailback,
  43.     'summary-file!'    => \$summary_file,
  44.  
  45.     'debug=s'    => \%debug,
  46.     'test-only=s'    => \$tst_only,
  47. ) or exit;
  48.  
  49. my $exit = 0;
  50.  
  51. if ($#ARGV < 0) {
  52.     print "usage: $P [options] patchfile\n";
  53.     print "version: $V\n";
  54.     print "options: -q               => quiet\n";
  55.     print "         --no-tree        => run without a kernel tree\n";
  56.     print "         --terse          => one line per report\n";
  57.     print "         --emacs          => emacs compile window format\n";
  58.     print "         --file           => check a source file\n";
  59.     print "         --strict         => enable more subjective tests\n";
  60.     print "         --root           => path to the kernel tree root\n";
  61.     print "         --no-summary     => suppress the per-file summary\n";
  62.     print "         --summary-file   => include the filename in summary\n";
  63.     exit(1);
  64. }
  65.  
  66. my $dbg_values = 0;
  67. my $dbg_possible = 0;
  68. my $dbg_type = 0;
  69. for my $key (keys %debug) {
  70.     eval "\${dbg_$key} = '$debug{$key}';"
  71. }
  72.  
  73. if ($terse) {
  74.     $emacs = 1;
  75.     $quiet++;
  76. }
  77.  
  78. if ($tree) {
  79.     if (defined $root) {
  80.         if (!top_of_kernel_tree($root)) {
  81.             die "$P: $root: --root does not point at a valid tree\n";
  82.         }
  83.     } else {
  84.         if (top_of_kernel_tree('.')) {
  85.             $root = '.';
  86.         } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
  87.                         top_of_kernel_tree($1)) {
  88.             $root = $1;
  89.         }
  90.     }
  91.  
  92.     if (!defined $root) {
  93.         print "Must be run from the top-level dir. of a kernel tree\n";
  94.         exit(2);
  95.     }
  96. }
  97.  
  98. my $emitted_corrupt = 0;
  99.  
  100. our $Ident       = qr{[A-Za-z_][A-Za-z\d_]*};
  101. our $Storage    = qr{extern|static|asmlinkage};
  102. our $Sparse    = qr{
  103.             __user|
  104.             __kernel|
  105.             __force|
  106.             __iomem|
  107.             __must_check|
  108.             __init_refok|
  109.             __kprobes
  110.         }x;
  111. our $Attribute    = qr{
  112.             const|
  113.             __read_mostly|
  114.             __kprobes|
  115.             __(?:mem|cpu|dev|)(?:initdata|init)
  116.           }x;
  117. our $Modifier;
  118. our $Inline    = qr{inline|__always_inline|noinline};
  119. our $Member    = qr{->$Ident|\.$Ident|\[[^]]*\]};
  120. our $Lval    = qr{$Ident(?:$Member)*};
  121.  
  122. our $Constant    = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
  123. our $Assignment    = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
  124. our $Operators    = qr{
  125.             <=|>=|==|!=|
  126.             =>|->|<<|>>|<|>|!|~|
  127.             &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
  128.           }x;
  129.  
  130. our $NonptrType;
  131. our $Type;
  132. our $Declare;
  133.  
  134. our $UTF8    = qr {
  135.     [\x09\x0A\x0D\x20-\x7E]              # ASCII
  136.     | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
  137.     |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
  138.     | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
  139.     |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
  140.     |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
  141.     | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
  142.     |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
  143. }x;
  144.  
  145. our @typeList = (
  146.     qr{void},
  147.     qr{(?:unsigned\s+)?char},
  148.     qr{(?:unsigned\s+)?short},
  149.     qr{(?:unsigned\s+)?int},
  150.     qr{(?:unsigned\s+)?long},
  151.     qr{(?:unsigned\s+)?long\s+int},
  152.     qr{(?:unsigned\s+)?long\s+long},
  153.     qr{(?:unsigned\s+)?long\s+long\s+int},
  154.     qr{unsigned},
  155.     qr{float},
  156.     qr{double},
  157.     qr{bool},
  158.     qr{(?:__)?(?:u|s|be|le)(?:8|16|32|64)},
  159.     qr{struct\s+$Ident},
  160.     qr{union\s+$Ident},
  161.     qr{enum\s+$Ident},
  162.     qr{${Ident}_t},
  163.     qr{${Ident}_handler},
  164.     qr{${Ident}_handler_fn},
  165. );
  166. our @modifierList = (
  167.     qr{fastcall},
  168. );
  169.  
  170. sub build_types {
  171.     my $mods = "(?x:  \n" . join("|\n  ", @modifierList) . "\n)";
  172.     my $all = "(?x:  \n" . join("|\n  ", @typeList) . "\n)";
  173.     $Modifier    = qr{(?:$Attribute|$Sparse|$mods)};
  174.     $NonptrType    = qr{
  175.             (?:$Modifier\s+|const\s+)*
  176.             (?:
  177.                 (?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
  178.                 (?:${all}\b)
  179.             )
  180.             (?:\s+$Modifier|\s+const)*
  181.           }x;
  182.     $Type    = qr{
  183.             $NonptrType
  184.             (?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
  185.             (?:\s+$Inline|\s+$Modifier)*
  186.           }x;
  187.     $Declare    = qr{(?:$Storage\s+)?$Type};
  188. }
  189. build_types();
  190.  
  191. $chk_signoff = 0 if ($file);
  192.  
  193. my @dep_includes = ();
  194. my @dep_functions = ();
  195. my $removal = "Documentation/feature-removal-schedule.txt";
  196. if ($tree && -f "$root/$removal") {
  197.     open(REMOVE, "<$root/$removal") ||
  198.                 die "$P: $removal: open failed - $!\n";
  199.     while (<REMOVE>) {
  200.         if (/^Check:\s+(.*\S)/) {
  201.             for my $entry (split(/[, ]+/, $1)) {
  202.                 if ($entry =~ m@include/(.*)@) {
  203.                     push(@dep_includes, $1);
  204.  
  205.                 } elsif ($entry !~ m@/@) {
  206.                     push(@dep_functions, $entry);
  207.                 }
  208.             }
  209.         }
  210.     }
  211. }
  212.  
  213. my @rawlines = ();
  214. my @lines = ();
  215. my $vname;
  216. for my $filename (@ARGV) {
  217.     if ($file) {
  218.         open(FILE, "diff -u /dev/null $filename|") ||
  219.             die "$P: $filename: diff failed - $!\n";
  220.     } else {
  221.         open(FILE, "<$filename") ||
  222.             die "$P: $filename: open failed - $!\n";
  223.     }
  224.     if ($filename eq '-') {
  225.         $vname = 'Your patch';
  226.     } else {
  227.         $vname = $filename;
  228.     }
  229.     while (<FILE>) {
  230.         chomp;
  231.         push(@rawlines, $_);
  232.     }
  233.     close(FILE);
  234.     if (!process($filename)) {
  235.         $exit = 1;
  236.     }
  237.     @rawlines = ();
  238.     @lines = ();
  239. }
  240.  
  241. exit($exit);
  242.  
  243. sub top_of_kernel_tree {
  244.     my ($root) = @_;
  245.  
  246.     my @tree_check = (
  247.         "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
  248.         "README", "Documentation", "arch", "include", "drivers",
  249.         "fs", "init", "ipc", "kernel", "lib", "scripts",
  250.     );
  251.  
  252.     foreach my $check (@tree_check) {
  253.         if (! -e $root . '/' . $check) {
  254.             return 0;
  255.         }
  256.     }
  257.     return 1;
  258. }
  259.  
  260. sub expand_tabs {
  261.     my ($str) = @_;
  262.  
  263.     my $res = '';
  264.     my $n = 0;
  265.     for my $c (split(//, $str)) {
  266.         if ($c eq "\t") {
  267.             $res .= ' ';
  268.             $n++;
  269.             for (; ($n % 8) != 0; $n++) {
  270.                 $res .= ' ';
  271.             }
  272.             next;
  273.         }
  274.         $res .= $c;
  275.         $n++;
  276.     }
  277.  
  278.     return $res;
  279. }
  280. sub copy_spacing {
  281.     (my $res = shift) =~ tr/\t/ /c;
  282.     return $res;
  283. }
  284.  
  285. sub line_stats {
  286.     my ($line) = @_;
  287.  
  288.     # Drop the diff line leader and expand tabs
  289.     $line =~ s/^.//;
  290.     $line = expand_tabs($line);
  291.  
  292.     # Pick the indent from the front of the line.
  293.     my ($white) = ($line =~ /^(\s*)/);
  294.  
  295.     return (length($line), length($white));
  296. }
  297.  
  298. my $sanitise_quote = '';
  299.  
  300. sub sanitise_line_reset {
  301.     my ($in_comment) = @_;
  302.  
  303.     if ($in_comment) {
  304.         $sanitise_quote = '*/';
  305.     } else {
  306.         $sanitise_quote = '';
  307.     }
  308. }
  309. sub sanitise_line {
  310.     my ($line) = @_;
  311.  
  312.     my $res = '';
  313.     my $l = '';
  314.  
  315.     my $qlen = 0;
  316.     my $off = 0;
  317.     my $c;
  318.  
  319.     # Always copy over the diff marker.
  320.     $res = substr($line, 0, 1);
  321.  
  322.     for ($off = 1; $off < length($line); $off++) {
  323.         $c = substr($line, $off, 1);
  324.  
  325.         # Comments we are wacking completly including the begin
  326.         # and end, all to $;.
  327.         if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
  328.             $sanitise_quote = '*/';
  329.  
  330.             substr($res, $off, 2, "$;$;");
  331.             $off++;
  332.             next;
  333.         }
  334.         if (substr($line, $off, 2) eq '*/') {
  335.             $sanitise_quote = '';
  336.             substr($res, $off, 2, "$;$;");
  337.             $off++;
  338.             next;
  339.         }
  340.  
  341.         # A \ in a string means ignore the next character.
  342.         if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
  343.             $c eq "\\") {
  344.             substr($res, $off, 2, 'XX');
  345.             $off++;
  346.             next;
  347.         }
  348.         # Regular quotes.
  349.         if ($c eq "'" || $c eq '"') {
  350.             if ($sanitise_quote eq '') {
  351.                 $sanitise_quote = $c;
  352.  
  353.                 substr($res, $off, 1, $c);
  354.                 next;
  355.             } elsif ($sanitise_quote eq $c) {
  356.                 $sanitise_quote = '';
  357.             }
  358.         }
  359.  
  360.         #print "SQ:$sanitise_quote\n";
  361.         if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
  362.             substr($res, $off, 1, $;);
  363.         } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
  364.             substr($res, $off, 1, 'X');
  365.         } else {
  366.             substr($res, $off, 1, $c);
  367.         }
  368.     }
  369.  
  370.     # The pathname on a #include may be surrounded by '<' and '>'.
  371.     if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
  372.         my $clean = 'X' x length($1);
  373.         $res =~ s@\<.*\>@<$clean>@;
  374.  
  375.     # The whole of a #error is a string.
  376.     } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
  377.         my $clean = 'X' x length($1);
  378.         $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
  379.     }
  380.  
  381.     return $res;
  382. }
  383.  
  384. sub ctx_statement_block {
  385.     my ($linenr, $remain, $off) = @_;
  386.     my $line = $linenr - 1;
  387.     my $blk = '';
  388.     my $soff = $off;
  389.     my $coff = $off - 1;
  390.     my $coff_set = 0;
  391.  
  392.     my $loff = 0;
  393.  
  394.     my $type = '';
  395.     my $level = 0;
  396.     my $p;
  397.     my $c;
  398.     my $len = 0;
  399.  
  400.     my $remainder;
  401.     while (1) {
  402.         #warn "CSB: blk<$blk> remain<$remain>\n";
  403.         # If we are about to drop off the end, pull in more
  404.         # context.
  405.         if ($off >= $len) {
  406.             for (; $remain > 0; $line++) {
  407.                 next if ($lines[$line] =~ /^-/);
  408.                 $remain--;
  409.                 $loff = $len;
  410.                 $blk .= $lines[$line] . "\n";
  411.                 $len = length($blk);
  412.                 $line++;
  413.                 last;
  414.             }
  415.             # Bail if there is no further context.
  416.             #warn "CSB: blk<$blk> off<$off> len<$len>\n";
  417.             if ($off >= $len) {
  418.                 last;
  419.             }
  420.         }
  421.         $p = $c;
  422.         $c = substr($blk, $off, 1);
  423.         $remainder = substr($blk, $off);
  424.  
  425.         #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
  426.         # Statement ends at the ';' or a close '}' at the
  427.         # outermost level.
  428.         if ($level == 0 && $c eq ';') {
  429.             last;
  430.         }
  431.  
  432.         # An else is really a conditional as long as its not else if
  433.         if ($level == 0 && $coff_set == 0 &&
  434.                 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
  435.                 $remainder =~ /^(else)(?:\s|{)/ &&
  436.                 $remainder !~ /^else\s+if\b/) {
  437.             $coff = $off + length($1) - 1;
  438.             $coff_set = 1;
  439.             #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
  440.             #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
  441.         }
  442.  
  443.         if (($type eq '' || $type eq '(') && $c eq '(') {
  444.             $level++;
  445.             $type = '(';
  446.         }
  447.         if ($type eq '(' && $c eq ')') {
  448.             $level--;
  449.             $type = ($level != 0)? '(' : '';
  450.  
  451.             if ($level == 0 && $coff < $soff) {
  452.                 $coff = $off;
  453.                 $coff_set = 1;
  454.                 #warn "CSB: mark coff<$coff>\n";
  455.             }
  456.         }
  457.         if (($type eq '' || $type eq '{') && $c eq '{') {
  458.             $level++;
  459.             $type = '{';
  460.         }
  461.         if ($type eq '{' && $c eq '}') {
  462.             $level--;
  463.             $type = ($level != 0)? '{' : '';
  464.  
  465.             if ($level == 0) {
  466.                 last;
  467.             }
  468.         }
  469.         $off++;
  470.     }
  471.     # We are truly at the end, so shuffle to the next line.
  472.     if ($off == $len) {
  473.         $loff = $len + 1;
  474.         $line++;
  475.         $remain--;
  476.     }
  477.  
  478.     my $statement = substr($blk, $soff, $off - $soff + 1);
  479.     my $condition = substr($blk, $soff, $coff - $soff + 1);
  480.  
  481.     #warn "STATEMENT<$statement>\n";
  482.     #warn "CONDITION<$condition>\n";
  483.  
  484.     #print "coff<$coff> soff<$off> loff<$loff>\n";
  485.  
  486.     return ($statement, $condition,
  487.             $line, $remain + 1, $off - $loff + 1, $level);
  488. }
  489.  
  490. sub statement_lines {
  491.     my ($stmt) = @_;
  492.  
  493.     # Strip the diff line prefixes and rip blank lines at start and end.
  494.     $stmt =~ s/(^|\n)./$1/g;
  495.     $stmt =~ s/^\s*//;
  496.     $stmt =~ s/\s*$//;
  497.  
  498.     my @stmt_lines = ($stmt =~ /\n/g);
  499.  
  500.     return $#stmt_lines + 2;
  501. }
  502.  
  503. sub statement_rawlines {
  504.     my ($stmt) = @_;
  505.  
  506.     my @stmt_lines = ($stmt =~ /\n/g);
  507.  
  508.     return $#stmt_lines + 2;
  509. }
  510.  
  511. sub statement_block_size {
  512.     my ($stmt) = @_;
  513.  
  514.     $stmt =~ s/(^|\n)./$1/g;
  515.     $stmt =~ s/^\s*{//;
  516.     $stmt =~ s/}\s*$//;
  517.     $stmt =~ s/^\s*//;
  518.     $stmt =~ s/\s*$//;
  519.  
  520.     my @stmt_lines = ($stmt =~ /\n/g);
  521.     my @stmt_statements = ($stmt =~ /;/g);
  522.  
  523.     my $stmt_lines = $#stmt_lines + 2;
  524.     my $stmt_statements = $#stmt_statements + 1;
  525.  
  526.     if ($stmt_lines > $stmt_statements) {
  527.         return $stmt_lines;
  528.     } else {
  529.         return $stmt_statements;
  530.     }
  531. }
  532.  
  533. sub ctx_statement_full {
  534.     my ($linenr, $remain, $off) = @_;
  535.     my ($statement, $condition, $level);
  536.  
  537.     my (@chunks);
  538.  
  539.     # Grab the first conditional/block pair.
  540.     ($statement, $condition, $linenr, $remain, $off, $level) =
  541.                 ctx_statement_block($linenr, $remain, $off);
  542.     #print "F: c<$condition> s<$statement> remain<$remain>\n";
  543.     push(@chunks, [ $condition, $statement ]);
  544.     if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
  545.         return ($level, $linenr, @chunks);
  546.     }
  547.  
  548.     # Pull in the following conditional/block pairs and see if they
  549.     # could continue the statement.
  550.     for (;;) {
  551.         ($statement, $condition, $linenr, $remain, $off, $level) =
  552.                 ctx_statement_block($linenr, $remain, $off);
  553.         #print "C: c<$condition> s<$statement> remain<$remain>\n";
  554.         last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
  555.         #print "C: push\n";
  556.         push(@chunks, [ $condition, $statement ]);
  557.     }
  558.  
  559.     return ($level, $linenr, @chunks);
  560. }
  561.  
  562. sub ctx_block_get {
  563.     my ($linenr, $remain, $outer, $open, $close, $off) = @_;
  564.     my $line;
  565.     my $start = $linenr - 1;
  566.     my $blk = '';
  567.     my @o;
  568.     my @c;
  569.     my @res = ();
  570.  
  571.     my $level = 0;
  572.     for ($line = $start; $remain > 0; $line++) {
  573.         next if ($rawlines[$line] =~ /^-/);
  574.         $remain--;
  575.  
  576.         $blk .= $rawlines[$line];
  577.         foreach my $c (split(//, $rawlines[$line])) {
  578.             ##print "C<$c>L<$level><$open$close>O<$off>\n";
  579.             if ($off > 0) {
  580.                 $off--;
  581.                 next;
  582.             }
  583.  
  584.             if ($c eq $close && $level > 0) {
  585.                 $level--;
  586.                 last if ($level == 0);
  587.             } elsif ($c eq $open) {
  588.                 $level++;
  589.             }
  590.         }
  591.  
  592.         if (!$outer || $level <= 1) {
  593.             push(@res, $rawlines[$line]);
  594.         }
  595.  
  596.         last if ($level == 0);
  597.     }
  598.  
  599.     return ($level, @res);
  600. }
  601. sub ctx_block_outer {
  602.     my ($linenr, $remain) = @_;
  603.  
  604.     my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
  605.     return @r;
  606. }
  607. sub ctx_block {
  608.     my ($linenr, $remain) = @_;
  609.  
  610.     my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
  611.     return @r;
  612. }
  613. sub ctx_statement {
  614.     my ($linenr, $remain, $off) = @_;
  615.  
  616.     my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
  617.     return @r;
  618. }
  619. sub ctx_block_level {
  620.     my ($linenr, $remain) = @_;
  621.  
  622.     return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
  623. }
  624. sub ctx_statement_level {
  625.     my ($linenr, $remain, $off) = @_;
  626.  
  627.     return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
  628. }
  629.  
  630. sub ctx_locate_comment {
  631.     my ($first_line, $end_line) = @_;
  632.  
  633.     # Catch a comment on the end of the line itself.
  634.     my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
  635.     return $current_comment if (defined $current_comment);
  636.  
  637.     # Look through the context and try and figure out if there is a
  638.     # comment.
  639.     my $in_comment = 0;
  640.     $current_comment = '';
  641.     for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
  642.         my $line = $rawlines[$linenr - 1];
  643.         #warn "           $line\n";
  644.         if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
  645.             $in_comment = 1;
  646.         }
  647.         if ($line =~ m@/\*@) {
  648.             $in_comment = 1;
  649.         }
  650.         if (!$in_comment && $current_comment ne '') {
  651.             $current_comment = '';
  652.         }
  653.         $current_comment .= $line . "\n" if ($in_comment);
  654.         if ($line =~ m@\*/@) {
  655.             $in_comment = 0;
  656.         }
  657.     }
  658.  
  659.     chomp($current_comment);
  660.     return($current_comment);
  661. }
  662. sub ctx_has_comment {
  663.     my ($first_line, $end_line) = @_;
  664.     my $cmt = ctx_locate_comment($first_line, $end_line);
  665.  
  666.     ##print "LINE: $rawlines[$end_line - 1 ]\n";
  667.     ##print "CMMT: $cmt\n";
  668.  
  669.     return ($cmt ne '');
  670. }
  671.  
  672. sub cat_vet {
  673.     my ($vet) = @_;
  674.     my ($res, $coded);
  675.  
  676.     $res = '';
  677.     while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
  678.         $res .= $1;
  679.         if ($2 ne '') {
  680.             $coded = sprintf("^%c", unpack('C', $2) + 64);
  681.             $res .= $coded;
  682.         }
  683.     }
  684.     $res =~ s/$/\$/;
  685.  
  686.     return $res;
  687. }
  688.  
  689. my $av_preprocessor = 0;
  690. my $av_pending;
  691. my @av_paren_type;
  692. my $av_pend_colon;
  693.  
  694. sub annotate_reset {
  695.     $av_preprocessor = 0;
  696.     $av_pending = '_';
  697.     @av_paren_type = ('E');
  698.     $av_pend_colon = 'O';
  699. }
  700.  
  701. sub annotate_values {
  702.     my ($stream, $type) = @_;
  703.  
  704.     my $res;
  705.     my $var = '_' x length($stream);
  706.     my $cur = $stream;
  707.  
  708.     print "$stream\n" if ($dbg_values > 1);
  709.  
  710.     while (length($cur)) {
  711.         @av_paren_type = ('E') if ($#av_paren_type < 0);
  712.         print " <" . join('', @av_paren_type) .
  713.                 "> <$type> <$av_pending>" if ($dbg_values > 1);
  714.         if ($cur =~ /^(\s+)/o) {
  715.             print "WS($1)\n" if ($dbg_values > 1);
  716.             if ($1 =~ /\n/ && $av_preprocessor) {
  717.                 $type = pop(@av_paren_type);
  718.                 $av_preprocessor = 0;
  719.             }
  720.  
  721.         } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\()/) {
  722.             print "DECLARE($1)\n" if ($dbg_values > 1);
  723.             $type = 'T';
  724.  
  725.         } elsif ($cur =~ /^($Modifier)\s*/) {
  726.             print "MODIFIER($1)\n" if ($dbg_values > 1);
  727.             $type = 'T';
  728.  
  729.         } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
  730.             print "DEFINE($1,$2)\n" if ($dbg_values > 1);
  731.             $av_preprocessor = 1;
  732.             push(@av_paren_type, $type);
  733.             if ($2 ne '') {
  734.                 $av_pending = 'N';
  735.             }
  736.             $type = 'E';
  737.  
  738.         } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
  739.             print "UNDEF($1)\n" if ($dbg_values > 1);
  740.             $av_preprocessor = 1;
  741.             push(@av_paren_type, $type);
  742.  
  743.         } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
  744.             print "PRE_START($1)\n" if ($dbg_values > 1);
  745.             $av_preprocessor = 1;
  746.  
  747.             push(@av_paren_type, $type);
  748.             push(@av_paren_type, $type);
  749.             $type = 'E';
  750.  
  751.         } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
  752.             print "PRE_RESTART($1)\n" if ($dbg_values > 1);
  753.             $av_preprocessor = 1;
  754.  
  755.             push(@av_paren_type, $av_paren_type[$#av_paren_type]);
  756.  
  757.             $type = 'E';
  758.  
  759.         } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
  760.             print "PRE_END($1)\n" if ($dbg_values > 1);
  761.  
  762.             $av_preprocessor = 1;
  763.  
  764.             # Assume all arms of the conditional end as this
  765.             # one does, and continue as if the #endif was not here.
  766.             pop(@av_paren_type);
  767.             push(@av_paren_type, $type);
  768.             $type = 'E';
  769.  
  770.         } elsif ($cur =~ /^(\\\n)/o) {
  771.             print "PRECONT($1)\n" if ($dbg_values > 1);
  772.  
  773.         } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
  774.             print "ATTR($1)\n" if ($dbg_values > 1);
  775.             $av_pending = $type;
  776.             $type = 'N';
  777.  
  778.         } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
  779.             print "SIZEOF($1)\n" if ($dbg_values > 1);
  780.             if (defined $2) {
  781.                 $av_pending = 'V';
  782.             }
  783.             $type = 'N';
  784.  
  785.         } elsif ($cur =~ /^(if|while|typeof|__typeof__|for)\b/o) {
  786.             print "COND($1)\n" if ($dbg_values > 1);
  787.             $av_pending = 'N';
  788.             $type = 'N';
  789.  
  790.         } elsif ($cur =~/^(case)/o) {
  791.             print "CASE($1)\n" if ($dbg_values > 1);
  792.             $av_pend_colon = 'C';
  793.             $type = 'N';
  794.  
  795.         } elsif ($cur =~/^(return|else|goto)/o) {
  796.             print "KEYWORD($1)\n" if ($dbg_values > 1);
  797.             $type = 'N';
  798.  
  799.         } elsif ($cur =~ /^(\()/o) {
  800.             print "PAREN('$1')\n" if ($dbg_values > 1);
  801.             push(@av_paren_type, $av_pending);
  802.             $av_pending = '_';
  803.             $type = 'N';
  804.  
  805.         } elsif ($cur =~ /^(\))/o) {
  806.             my $new_type = pop(@av_paren_type);
  807.             if ($new_type ne '_') {
  808.                 $type = $new_type;
  809.                 print "PAREN('$1') -> $type\n"
  810.                             if ($dbg_values > 1);
  811.             } else {
  812.                 print "PAREN('$1')\n" if ($dbg_values > 1);
  813.             }
  814.  
  815.         } elsif ($cur =~ /^($Ident)\s*\(/o) {
  816.             print "FUNC($1)\n" if ($dbg_values > 1);
  817.             $type = 'V';
  818.             $av_pending = 'V';
  819.  
  820.         } elsif ($cur =~ /^($Ident\s*):/) {
  821.             if ($type eq 'E') {
  822.                 $av_pend_colon = 'L';
  823.             } elsif ($type eq 'T') {
  824.                 $av_pend_colon = 'B';
  825.             }
  826.             print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
  827.             $type = 'V';
  828.  
  829.         } elsif ($cur =~ /^($Ident|$Constant)/o) {
  830.             print "IDENT($1)\n" if ($dbg_values > 1);
  831.             $type = 'V';
  832.  
  833.         } elsif ($cur =~ /^($Assignment)/o) {
  834.             print "ASSIGN($1)\n" if ($dbg_values > 1);
  835.             $type = 'N';
  836.  
  837.         } elsif ($cur =~/^(;|{|})/) {
  838.             print "END($1)\n" if ($dbg_values > 1);
  839.             $type = 'E';
  840.             $av_pend_colon = 'O';
  841.  
  842.         } elsif ($cur =~ /^(\?)/o) {
  843.             print "QUESTION($1)\n" if ($dbg_values > 1);
  844.             $type = 'N';
  845.  
  846.         } elsif ($cur =~ /^(:)/o) {
  847.             print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
  848.  
  849.             substr($var, length($res), 1, $av_pend_colon);
  850.             if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
  851.                 $type = 'E';
  852.             } else {
  853.                 $type = 'N';
  854.             }
  855.             $av_pend_colon = 'O';
  856.  
  857.         } elsif ($cur =~ /^(;|\[)/o) {
  858.             print "CLOSE($1)\n" if ($dbg_values > 1);
  859.             $type = 'N';
  860.  
  861.         } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&(?!\&))/o) {
  862.             my $variant;
  863.  
  864.             print "OPV($1)\n" if ($dbg_values > 1);
  865.             if ($type eq 'V') {
  866.                 $variant = 'B';
  867.             } else {
  868.                 $variant = 'U';
  869.             }
  870.  
  871.             substr($var, length($res), 1, $variant);
  872.             $type = 'N';
  873.  
  874.         } elsif ($cur =~ /^($Operators)/o) {
  875.             print "OP($1)\n" if ($dbg_values > 1);
  876.             if ($1 ne '++' && $1 ne '--') {
  877.                 $type = 'N';
  878.             }
  879.  
  880.         } elsif ($cur =~ /(^.)/o) {
  881.             print "C($1)\n" if ($dbg_values > 1);
  882.         }
  883.         if (defined $1) {
  884.             $cur = substr($cur, length($1));
  885.             $res .= $type x length($1);
  886.         }
  887.     }
  888.  
  889.     return ($res, $var);
  890. }
  891.  
  892. sub possible {
  893.     my ($possible, $line) = @_;
  894.  
  895.     print "CHECK<$possible> ($line)\n" if ($dbg_possible > 1);
  896.     if ($possible !~ /^(?:$Modifier|$Storage|$Type|DEFINE_\S+)$/ &&
  897.         $possible ne 'goto' && $possible ne 'return' &&
  898.         $possible ne 'case' && $possible ne 'else' &&
  899.         $possible ne 'asm' && $possible ne '__asm__' &&
  900.         $possible !~ /^(typedef|struct|enum)\b/) {
  901.         # Check for modifiers.
  902.         $possible =~ s/\s*$Storage\s*//g;
  903.         $possible =~ s/\s*$Sparse\s*//g;
  904.         if ($possible =~ /^\s*$/) {
  905.  
  906.         } elsif ($possible =~ /\s/) {
  907.             $possible =~ s/\s*$Type\s*//g;
  908.             for my $modifier (split(' ', $possible)) {
  909.                 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
  910.                 push(@modifierList, $modifier);
  911.             }
  912.  
  913.         } else {
  914.             warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
  915.             push(@typeList, $possible);
  916.         }
  917.         build_types();
  918.     }
  919. }
  920.  
  921. my $prefix = '';
  922.  
  923. sub report {
  924.     if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) {
  925.         return 0;
  926.     }
  927.     my $line = $prefix . $_[0];
  928.  
  929.     $line = (split('\n', $line))[0] . "\n" if ($terse);
  930.  
  931.     push(our @report, $line);
  932.  
  933.     return 1;
  934. }
  935. sub report_dump {
  936.     our @report;
  937. }
  938. sub ERROR {
  939.     if (report("ERROR: $_[0]\n")) {
  940.         our $clean = 0;
  941.         our $cnt_error++;
  942.     }
  943. }
  944. sub WARN {
  945.     if (report("WARNING: $_[0]\n")) {
  946.         our $clean = 0;
  947.         our $cnt_warn++;
  948.     }
  949. }
  950. sub CHK {
  951.     if ($check && report("CHECK: $_[0]\n")) {
  952.         our $clean = 0;
  953.         our $cnt_chk++;
  954.     }
  955. }
  956.  
  957. sub process {
  958.     my $filename = shift;
  959.  
  960.     my $linenr=0;
  961.     my $prevline="";
  962.     my $prevrawline="";
  963.     my $stashline="";
  964.     my $stashrawline="";
  965.  
  966.     my $length;
  967.     my $indent;
  968.     my $previndent=0;
  969.     my $stashindent=0;
  970.  
  971.     our $clean = 1;
  972.     my $signoff = 0;
  973.     my $is_patch = 0;
  974.  
  975.     our @report = ();
  976.     our $cnt_lines = 0;
  977.     our $cnt_error = 0;
  978.     our $cnt_warn = 0;
  979.     our $cnt_chk = 0;
  980.  
  981.     # Trace the real file/line as we go.
  982.     my $realfile = '';
  983.     my $realline = 0;
  984.     my $realcnt = 0;
  985.     my $here = '';
  986.     my $in_comment = 0;
  987.     my $comment_edge = 0;
  988.     my $first_line = 0;
  989.  
  990.     my $prev_values = 'E';
  991.  
  992.     # suppression flags
  993.     my %suppress_ifbraces;
  994.  
  995.     # Pre-scan the patch sanitizing the lines.
  996.     # Pre-scan the patch looking for any __setup documentation.
  997.     #
  998.     my @setup_docs = ();
  999.     my $setup_docs = 0;
  1000.  
  1001.     sanitise_line_reset();
  1002.     my $line;
  1003.     foreach my $rawline (@rawlines) {
  1004.         $linenr++;
  1005.         $line = $rawline;
  1006.  
  1007.         if ($rawline=~/^\+\+\+\s+(\S+)/) {
  1008.             $setup_docs = 0;
  1009.             if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
  1010.                 $setup_docs = 1;
  1011.             }
  1012.             #next;
  1013.         }
  1014.         if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
  1015.             $realline=$1-1;
  1016.             if (defined $2) {
  1017.                 $realcnt=$3+1;
  1018.             } else {
  1019.                 $realcnt=1+1;
  1020.             }
  1021.             $in_comment = 0;
  1022.  
  1023.             # Guestimate if this is a continuing comment.  Run
  1024.             # the context looking for a comment "edge".  If this
  1025.             # edge is a close comment then we must be in a comment
  1026.             # at context start.
  1027.             my $edge;
  1028.             for (my $ln = $linenr + 1; $ln < ($linenr + $realcnt); $ln++) {
  1029.                 next if ($line =~ /^-/);
  1030.                 ($edge) = ($rawlines[$ln - 1] =~ m@(/\*|\*/)@);
  1031.                 last if (defined $edge);
  1032.             }
  1033.             if (defined $edge && $edge eq '*/') {
  1034.                 $in_comment = 1;
  1035.             }
  1036.  
  1037.             # Guestimate if this is a continuing comment.  If this
  1038.             # is the start of a diff block and this line starts
  1039.             # ' *' then it is very likely a comment.
  1040.             if (!defined $edge &&
  1041.                 $rawlines[$linenr] =~ m@^.\s* \*(?:\s|$)@)
  1042.             {
  1043.                 $in_comment = 1;
  1044.             }
  1045.  
  1046.             ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
  1047.             sanitise_line_reset($in_comment);
  1048.  
  1049.         } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
  1050.             # Standardise the strings and chars within the input to
  1051.             # simplify matching -- only bother with positive lines.
  1052.             $line = sanitise_line($rawline);
  1053.         }
  1054.         push(@lines, $line);
  1055.  
  1056.         if ($realcnt > 1) {
  1057.             $realcnt-- if ($line =~ /^(?:\+| |$)/);
  1058.         } else {
  1059.             $realcnt = 0;
  1060.         }
  1061.  
  1062.         #print "==>$rawline\n";
  1063.         #print "-->$line\n";
  1064.  
  1065.         if ($setup_docs && $line =~ /^\+/) {
  1066.             push(@setup_docs, $line);
  1067.         }
  1068.     }
  1069.  
  1070.     $prefix = '';
  1071.  
  1072.     $realcnt = 0;
  1073.     $linenr = 0;
  1074.     foreach my $line (@lines) {
  1075.         $linenr++;
  1076.  
  1077.         my $rawline = $rawlines[$linenr - 1];
  1078.  
  1079. #extract the line range in the file after the patch is applied
  1080.         if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
  1081.             $is_patch = 1;
  1082.             $first_line = $linenr + 1;
  1083.             $realline=$1-1;
  1084.             if (defined $2) {
  1085.                 $realcnt=$3+1;
  1086.             } else {
  1087.                 $realcnt=1+1;
  1088.             }
  1089.             annotate_reset();
  1090.             $prev_values = 'E';
  1091.  
  1092.             %suppress_ifbraces = ();
  1093.             next;
  1094.  
  1095. # track the line number as we move through the hunk, note that
  1096. # new versions of GNU diff omit the leading space on completely
  1097. # blank context lines so we need to count that too.
  1098.         } elsif ($line =~ /^( |\+|$)/) {
  1099.             $realline++;
  1100.             $realcnt-- if ($realcnt != 0);
  1101.  
  1102.             # Measure the line length and indent.
  1103.             ($length, $indent) = line_stats($rawline);
  1104.  
  1105.             # Track the previous line.
  1106.             ($prevline, $stashline) = ($stashline, $line);
  1107.             ($previndent, $stashindent) = ($stashindent, $indent);
  1108.             ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
  1109.  
  1110.             #warn "line<$line>\n";
  1111.  
  1112.         } elsif ($realcnt == 1) {
  1113.             $realcnt--;
  1114.         }
  1115.  
  1116. #make up the handle for any error we report on this line
  1117.         $prefix = "$filename:$realline: " if ($emacs && $file);
  1118.         $prefix = "$filename:$linenr: " if ($emacs && !$file);
  1119.  
  1120.         $here = "#$linenr: " if (!$file);
  1121.         $here = "#$realline: " if ($file);
  1122.  
  1123.         # extract the filename as it passes
  1124.         if ($line=~/^\+\+\+\s+(\S+)/) {
  1125.             $realfile = $1;
  1126.             $realfile =~ s@^[^/]*/@@;
  1127.  
  1128.             if ($realfile =~ m@include/asm/@) {
  1129.                 ERROR("do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
  1130.             }
  1131.             next;
  1132.         }
  1133.  
  1134.         $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
  1135.  
  1136.         my $hereline = "$here\n$rawline\n";
  1137.         my $herecurr = "$here\n$rawline\n";
  1138.         my $hereprev = "$here\n$prevrawline\n$rawline\n";
  1139.  
  1140.         $cnt_lines++ if ($realcnt != 0);
  1141.  
  1142. #check the patch for a signoff:
  1143.         if ($line =~ /^\s*signed-off-by:/i) {
  1144.             # This is a signoff, if ugly, so do not double report.
  1145.             $signoff++;
  1146.             if (!($line =~ /^\s*Signed-off-by:/)) {
  1147.                 WARN("Signed-off-by: is the preferred form\n" .
  1148.                     $herecurr);
  1149.             }
  1150.             if ($line =~ /^\s*signed-off-by:\S/i) {
  1151.                 WARN("space required after Signed-off-by:\n" .
  1152.                     $herecurr);
  1153.             }
  1154.         }
  1155.  
  1156. # Check for wrappage within a valid hunk of the file
  1157.         if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
  1158.             ERROR("patch seems to be corrupt (line wrapped?)\n" .
  1159.                 $herecurr) if (!$emitted_corrupt++);
  1160.         }
  1161.  
  1162. # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
  1163.         if (($realfile =~ /^$/ || $line =~ /^\+/) &&
  1164.             $rawline !~ m/^$UTF8*$/) {
  1165.             my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
  1166.  
  1167.             my $blank = copy_spacing($rawline);
  1168.             my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
  1169.             my $hereptr = "$hereline$ptr\n";
  1170.  
  1171.             ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
  1172.         }
  1173.  
  1174. #ignore lines being removed
  1175.         if ($line=~/^-/) {next;}
  1176.  
  1177. # check we are in a valid source file if not then ignore this hunk
  1178.         next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
  1179.  
  1180. #trailing whitespace
  1181.         if ($line =~ /^\+.*\015/) {
  1182.             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
  1183.             ERROR("DOS line endings\n" . $herevet);
  1184.  
  1185.         } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
  1186.             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
  1187.             ERROR("trailing whitespace\n" . $herevet);
  1188.         }
  1189. #80 column limit
  1190.         if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
  1191.             $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
  1192.             $line !~ /^\+\s*printk\s*\(\s*(?:KERN_\S+\s*)?"[X\t]*"\s*(?:,|\)\s*;)\s*$/ &&
  1193.             $length > 80)
  1194.         {
  1195.             WARN("line over 80 characters\n" . $herecurr);
  1196.         }
  1197.  
  1198. # check for adding lines without a newline.
  1199.         if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
  1200.             WARN("adding a line without newline at end of file\n" . $herecurr);
  1201.         }
  1202.  
  1203. # check we are in a valid source file *.[hc] if not then ignore this hunk
  1204.         next if ($realfile !~ /\.[hc]$/);
  1205.  
  1206. # at the beginning of a line any tabs must come first and anything
  1207. # more than 8 must use tabs.
  1208.         if ($rawline =~ /^\+\s* \t\s*\S/ ||
  1209.             $rawline =~ /^\+\s*        \s*/) {
  1210.             my $herevet = "$here\n" . cat_vet($rawline) . "\n";
  1211.             ERROR("code indent should use tabs where possible\n" . $herevet);
  1212.         }
  1213.  
  1214. # check for RCS/CVS revision markers
  1215.         if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
  1216.             WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);
  1217.         }
  1218.  
  1219. # Check for potential 'bare' types
  1220.         my ($stat, $cond, $line_nr_next, $remain_next);
  1221.         if ($realcnt && $line =~ /.\s*\S/) {
  1222.             ($stat, $cond, $line_nr_next, $remain_next) =
  1223.                 ctx_statement_block($linenr, $realcnt, 0);
  1224.             $stat =~ s/\n./\n /g;
  1225.             $cond =~ s/\n./\n /g;
  1226.  
  1227.             my $s = $stat;
  1228.             $s =~ s/{.*$//s;
  1229.  
  1230.             # Ignore goto labels.
  1231.             if ($s =~ /$Ident:\*$/s) {
  1232.  
  1233.             # Ignore functions being called
  1234.             } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
  1235.  
  1236.             # declarations always start with types
  1237.             } elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+?)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|\(\*[^\)]*\))(?:\s*$Modifier)?\s*(?:;|=|,|\()/s) {
  1238.                 my $type = $1;
  1239.                 $type =~ s/\s+/ /g;
  1240.                 possible($type, "A:" . $s);
  1241.  
  1242.             # definitions in global scope can only start with types
  1243.             } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b/s) {
  1244.                 possible($1, "B:" . $s);
  1245.             }
  1246.  
  1247.             # any (foo ... *) is a pointer cast, and foo is a type
  1248.             while ($s =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/sg) {
  1249.                 possible($1, "C:" . $s);
  1250.             }
  1251.  
  1252.             # Check for any sort of function declaration.
  1253.             # int foo(something bar, other baz);
  1254.             # void (*store_gdt)(x86_descr_ptr *);
  1255.             if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
  1256.                 my ($name_len) = length($1);
  1257.  
  1258.                 my $ctx = $s;
  1259.                 substr($ctx, 0, $name_len + 1, '');
  1260.                 $ctx =~ s/\)[^\)]*$//;
  1261.  
  1262.                 for my $arg (split(/\s*,\s*/, $ctx)) {
  1263.                     if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
  1264.  
  1265.                         possible($1, "D:" . $s);
  1266.                     }
  1267.                 }
  1268.             }
  1269.  
  1270.         }
  1271.  
  1272. #
  1273. # Checks which may be anchored in the context.
  1274. #
  1275.  
  1276. # Check for switch () and associated case and default
  1277. # statements should be at the same indent.
  1278.         if ($line=~/\bswitch\s*\(.*\)/) {
  1279.             my $err = '';
  1280.             my $sep = '';
  1281.             my @ctx = ctx_block_outer($linenr, $realcnt);
  1282.             shift(@ctx);
  1283.             for my $ctx (@ctx) {
  1284.                 my ($clen, $cindent) = line_stats($ctx);
  1285.                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
  1286.                             $indent != $cindent) {
  1287.                     $err .= "$sep$ctx\n";
  1288.                     $sep = '';
  1289.                 } else {
  1290.                     $sep = "[...]\n";
  1291.                 }
  1292.             }
  1293.             if ($err ne '') {
  1294.                 ERROR("switch and case should be at the same indent\n$hereline$err");
  1295.             }
  1296.         }
  1297.         if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
  1298.             $line !~ /\G(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$/g) {
  1299.             ERROR("trailing statements should be on next line\n" . $herecurr);
  1300.         }
  1301.  
  1302. # if/while/etc brace do not go on next line, unless defining a do while loop,
  1303. # or if that brace on the next line is for something else
  1304.         if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
  1305.             my $pre_ctx = "$1$2";
  1306.  
  1307.             my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
  1308.             my $ctx_cnt = $realcnt - $#ctx - 1;
  1309.             my $ctx = join("\n", @ctx);
  1310.  
  1311.             my $ctx_ln = $linenr;
  1312.             my $ctx_skip = $realcnt;
  1313.  
  1314.             while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
  1315.                     defined $lines[$ctx_ln - 1] &&
  1316.                     $lines[$ctx_ln - 1] =~ /^-/)) {
  1317.                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
  1318.                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
  1319.                 $ctx_ln++;
  1320.             }
  1321.  
  1322.             #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
  1323.             #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
  1324.  
  1325.             if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
  1326.                 ERROR("that open brace { should be on the previous line\n" .
  1327.                     "$here\n$ctx\n$lines[$ctx_ln - 1]\n");
  1328.             }
  1329.             if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
  1330.                 $ctx =~ /\)\s*\;\s*$/ &&
  1331.                 defined $lines[$ctx_ln - 1])
  1332.             {
  1333.                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
  1334.                 if ($nindent > $indent) {
  1335.                     WARN("trailing semicolon indicates no statements, indent implies otherwise\n" .
  1336.                         "$here\n$ctx\n$lines[$ctx_ln - 1]\n");
  1337.                 }
  1338.             }
  1339.         }
  1340.  
  1341.         # Track the 'values' across context and added lines.
  1342.         my $opline = $line; $opline =~ s/^./ /;
  1343.         my ($curr_values, $curr_vars) =
  1344.                 annotate_values($opline . "\n", $prev_values);
  1345.         $curr_values = $prev_values . $curr_values;
  1346.         if ($dbg_values) {
  1347.             my $outline = $opline; $outline =~ s/\t/ /g;
  1348.             print "$linenr > .$outline\n";
  1349.             print "$linenr > $curr_values\n";
  1350.             print "$linenr >  $curr_vars\n";
  1351.         }
  1352.         $prev_values = substr($curr_values, -1);
  1353.  
  1354. #ignore lines not being added
  1355.         if ($line=~/^[^\+]/) {next;}
  1356.  
  1357. # TEST: allow direct testing of the type matcher.
  1358.         if ($dbg_type) {
  1359.             if ($line =~ /^.\s*$Declare\s*$/) {
  1360.                 ERROR("TEST: is type\n" . $herecurr);
  1361.             } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
  1362.                 ERROR("TEST: is not type ($1 is)\n". $herecurr);
  1363.             }
  1364.             next;
  1365.         }
  1366.  
  1367. # check for initialisation to aggregates open brace on the next line
  1368.         if ($prevline =~ /$Declare\s*$Ident\s*=\s*$/ &&
  1369.             $line =~ /^.\s*{/) {
  1370.             ERROR("that open brace { should be on the previous line\n" . $hereprev);
  1371.         }
  1372.  
  1373. #
  1374. # Checks which are anchored on the added line.
  1375. #
  1376.  
  1377. # check for malformed paths in #include statements (uses RAW line)
  1378.         if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
  1379.             my $path = $1;
  1380.             if ($path =~ m{//}) {
  1381.                 ERROR("malformed #include filename\n" .
  1382.                     $herecurr);
  1383.             }
  1384.         }
  1385.  
  1386. # no C99 // comments
  1387.         if ($line =~ m{//}) {
  1388.             ERROR("do not use C99 // comments\n" . $herecurr);
  1389.         }
  1390.         # Remove C99 comments.
  1391.         $line =~ s@//.*@@;
  1392.         $opline =~ s@//.*@@;
  1393.  
  1394. #EXPORT_SYMBOL should immediately follow its function closing }.
  1395.         if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
  1396.             ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
  1397.             my $name = $1;
  1398.             if (($prevline !~ /^}/) &&
  1399.                ($prevline !~ /^\+}/) &&
  1400.                ($prevline !~ /^ }/) &&
  1401.                ($prevline !~ /^.DECLARE_$Ident\(\Q$name\E\)/) &&
  1402.                ($prevline !~ /^.LIST_HEAD\(\Q$name\E\)/) &&
  1403.                ($prevline !~ /^.$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(/) &&
  1404.                ($prevline !~ /\b\Q$name\E(?:\s+$Attribute)?\s*(?:;|=|\[)/)) {
  1405.                 WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
  1406.             }
  1407.         }
  1408.  
  1409. # check for external initialisers.
  1410.         if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {
  1411.             ERROR("do not initialise externals to 0 or NULL\n" .
  1412.                 $herecurr);
  1413.         }
  1414. # check for static initialisers.
  1415.         if ($line =~ /\s*static\s.*=\s*(0|NULL|false)\s*;/) {
  1416.             ERROR("do not initialise statics to 0 or NULL\n" .
  1417.                 $herecurr);
  1418.         }
  1419.  
  1420. # check for new typedefs, only function parameters and sparse annotations
  1421. # make sense.
  1422.         if ($line =~ /\btypedef\s/ &&
  1423.             $line !~ /\btypedef\s+$Type\s+\(\s*\*?$Ident\s*\)\s*\(/ &&
  1424.             $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
  1425.             $line !~ /\b__bitwise(?:__|)\b/) {
  1426.             WARN("do not add new typedefs\n" . $herecurr);
  1427.         }
  1428.  
  1429. # * goes on variable not on type
  1430.         if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
  1431.             ERROR("\"(foo$1)\" should be \"(foo $1)\"\n" .
  1432.                 $herecurr);
  1433.  
  1434.         } elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) {
  1435.             ERROR("\"(foo $1 )\" should be \"(foo $1)\"\n" .
  1436.                 $herecurr);
  1437.  
  1438.         } elsif ($line =~ m{\b$NonptrType(\*+)(?:\s+(?:$Attribute|$Sparse))?\s+[A-Za-z\d_]+}) {
  1439.             ERROR("\"foo$1 bar\" should be \"foo $1bar\"\n" .
  1440.                 $herecurr);
  1441.  
  1442.         } elsif ($line =~ m{\b$NonptrType\s+(\*+)(?!\s+(?:$Attribute|$Sparse))\s+[A-Za-z\d_]+}) {
  1443.             ERROR("\"foo $1 bar\" should be \"foo $1bar\"\n" .
  1444.                 $herecurr);
  1445.         }
  1446.  
  1447. # # no BUG() or BUG_ON()
  1448. #         if ($line =~ /\b(BUG|BUG_ON)\b/) {
  1449. #             print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
  1450. #             print "$herecurr";
  1451. #             $clean = 0;
  1452. #         }
  1453.  
  1454.         if ($line =~ /\bLINUX_VERSION_CODE\b/) {
  1455.             WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
  1456.         }
  1457.  
  1458. # printk should use KERN_* levels.  Note that follow on printk's on the
  1459. # same line do not need a level, so we use the current block context
  1460. # to try and find and validate the current printk.  In summary the current
  1461. # printk includes all preceeding printk's which have no newline on the end.
  1462. # we assume the first bad printk is the one to report.
  1463.         if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
  1464.             my $ok = 0;
  1465.             for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
  1466.                 #print "CHECK<$lines[$ln - 1]\n";
  1467.                 # we have a preceeding printk if it ends
  1468.                 # with "\n" ignore it, else it is to blame
  1469.                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
  1470.                     if ($rawlines[$ln - 1] !~ m{\\n"}) {
  1471.                         $ok = 1;
  1472.                     }
  1473.                     last;
  1474.                 }
  1475.             }
  1476.             if ($ok == 0) {
  1477.                 WARN("printk() should include KERN_ facility level\n" . $herecurr);
  1478.             }
  1479.         }
  1480.  
  1481. # function brace can't be on same line, except for #defines of do while,
  1482. # or if closed on same line
  1483.         if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
  1484.             !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
  1485.             ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);
  1486.         }
  1487.  
  1488. # open braces for enum, union and struct go on the same line.
  1489.         if ($line =~ /^.\s*{/ &&
  1490.             $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
  1491.             ERROR("open brace '{' following $1 go on the same line\n" . $hereprev);
  1492.         }
  1493.  
  1494. # check for spacing round square brackets; allowed:
  1495. #  1. with a type on the left -- int [] a;
  1496. #  2. at the beginning of a line for slice initialisers -- [0..10] = 5,
  1497.         while ($line =~ /(.*?\s)\[/g) {
  1498.             my ($where, $prefix) = ($-[1], $1);
  1499.             if ($prefix !~ /$Type\s+$/ &&
  1500.                 ($where != 0 || $prefix !~ /^.\s+$/)) {
  1501.                 ERROR("space prohibited before open square bracket '['\n" . $herecurr);
  1502.             }
  1503.         }
  1504.  
  1505. # check for spaces between functions and their parentheses.
  1506.         while ($line =~ /($Ident)\s+\(/g) {
  1507.             my $name = $1;
  1508.             my $ctx_before = substr($line, 0, $-[1]);
  1509.             my $ctx = "$ctx_before$name";
  1510.  
  1511.             # Ignore those directives where spaces _are_ permitted.
  1512.             if ($name =~ /^(?:
  1513.                 if|for|while|switch|return|case|
  1514.                 volatile|__volatile__|
  1515.                 __attribute__|format|__extension__|
  1516.                 asm|__asm__)$/x)
  1517.             {
  1518.  
  1519.             # cpp #define statements have non-optional spaces, ie
  1520.             # if there is a space between the name and the open
  1521.             # parenthesis it is simply not a parameter group.
  1522.             } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
  1523.  
  1524.             # cpp #elif statement condition may start with a (
  1525.             } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
  1526.  
  1527.             # If this whole things ends with a type its most
  1528.             # likely a typedef for a function.
  1529.             } elsif ($ctx =~ /$Type$/) {
  1530.  
  1531.             } else {
  1532.                 WARN("space prohibited between function name and open parenthesis '('\n" . $herecurr);
  1533.             }
  1534.         }
  1535. # Check operator spacing.
  1536.         if (!($line=~/\#\s*include/)) {
  1537.             my $ops = qr{
  1538.                 <<=|>>=|<=|>=|==|!=|
  1539.                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
  1540.                 =>|->|<<|>>|<|>|=|!|~|
  1541.                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
  1542.                 \?|:
  1543.             }x;
  1544.             my @elements = split(/($ops|;)/, $opline);
  1545.             my $off = 0;
  1546.  
  1547.             my $blank = copy_spacing($opline);
  1548.  
  1549.             for (my $n = 0; $n < $#elements; $n += 2) {
  1550.                 $off += length($elements[$n]);
  1551.  
  1552.                 # Pick up the preceeding and succeeding characters.
  1553.                 my $ca = substr($opline, 0, $off);
  1554.                 my $cc = '';
  1555.                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
  1556.                     $cc = substr($opline, $off + length($elements[$n + 1]));
  1557.                 }
  1558.                 my $cb = "$ca$;$cc";
  1559.  
  1560.                 my $a = '';
  1561.                 $a = 'V' if ($elements[$n] ne '');
  1562.                 $a = 'W' if ($elements[$n] =~ /\s$/);
  1563.                 $a = 'C' if ($elements[$n] =~ /$;$/);
  1564.                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
  1565.                 $a = 'O' if ($elements[$n] eq '');
  1566.                 $a = 'E' if ($ca =~ /^\s*$/);
  1567.  
  1568.                 my $op = $elements[$n + 1];
  1569.  
  1570.                 my $c = '';
  1571.                 if (defined $elements[$n + 2]) {
  1572.                     $c = 'V' if ($elements[$n + 2] ne '');
  1573.                     $c = 'W' if ($elements[$n + 2] =~ /^\s/);
  1574.                     $c = 'C' if ($elements[$n + 2] =~ /^$;/);
  1575.                     $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
  1576.                     $c = 'O' if ($elements[$n + 2] eq '');
  1577.                     $c = 'E' if ($elements[$n + 2] =~ /\s*\\$/);
  1578.                 } else {
  1579.                     $c = 'E';
  1580.                 }
  1581.  
  1582.                 my $ctx = "${a}x${c}";
  1583.  
  1584.                 my $at = "(ctx:$ctx)";
  1585.  
  1586.                 my $ptr = substr($blank, 0, $off) . "^";
  1587.                 my $hereptr = "$hereline$ptr\n";
  1588.  
  1589.                 # Pull out the value of this operator.
  1590.                 my $op_type = substr($curr_values, $off + 1, 1);
  1591.  
  1592.                 # Get the full operator variant.
  1593.                 my $opv = $op . substr($curr_vars, $off, 1);
  1594.  
  1595.                 # Ignore operators passed as parameters.
  1596.                 if ($op_type ne 'V' &&
  1597.                     $ca =~ /\s$/ && $cc =~ /^\s*,/) {
  1598.  
  1599. #                # Ignore comments
  1600. #                } elsif ($op =~ /^$;+$/) {
  1601.  
  1602.                 # ; should have either the end of line or a space or \ after it
  1603.                 } elsif ($op eq ';') {
  1604.                     if ($ctx !~ /.x[WEBC]/ &&
  1605.                         $cc !~ /^\\/ && $cc !~ /^;/) {
  1606.                         ERROR("space required after that '$op' $at\n" . $hereptr);
  1607.                     }
  1608.  
  1609.                 # // is a comment
  1610.                 } elsif ($op eq '//') {
  1611.  
  1612.                 # No spaces for:
  1613.                 #   ->
  1614.                 #   :   when part of a bitfield
  1615.                 } elsif ($op eq '->' || $opv eq ':B') {
  1616.                     if ($ctx =~ /Wx.|.xW/) {
  1617.                         ERROR("spaces prohibited around that '$op' $at\n" . $hereptr);
  1618.                     }
  1619.  
  1620.                 # , must have a space on the right.
  1621.                 } elsif ($op eq ',') {
  1622.                     if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
  1623.                         ERROR("space required after that '$op' $at\n" . $hereptr);
  1624.                     }
  1625.  
  1626.                 # '*' as part of a type definition -- reported already.
  1627.                 } elsif ($opv eq '*_') {
  1628.                     #warn "'*' is part of type\n";
  1629.  
  1630.                 # unary operators should have a space before and
  1631.                 # none after.  May be left adjacent to another
  1632.                 # unary operator, or a cast
  1633.                 } elsif ($op eq '!' || $op eq '~' ||
  1634.                      $opv eq '*U' || $opv eq '-U' ||
  1635.                      $opv eq '&U') {
  1636.                     if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
  1637.                         ERROR("space required before that '$op' $at\n" . $hereptr);
  1638.                     }
  1639.                     if ($op eq '*' && $cc =~/\s*const\b/) {
  1640.                         # A unary '*' may be const
  1641.  
  1642.                     } elsif ($ctx =~ /.xW/) {
  1643.                         ERROR("space prohibited after that '$op' $at\n" . $hereptr);
  1644.                     }
  1645.  
  1646.                 # unary ++ and unary -- are allowed no space on one side.
  1647.                 } elsif ($op eq '++' or $op eq '--') {
  1648.                     if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
  1649.                         ERROR("space required one side of that '$op' $at\n" . $hereptr);
  1650.                     }
  1651.                     if ($ctx =~ /Wx[BE]/ ||
  1652.                         ($ctx =~ /Wx./ && $cc =~ /^;/)) {
  1653.                         ERROR("space prohibited before that '$op' $at\n" . $hereptr);
  1654.                     }
  1655.                     if ($ctx =~ /ExW/) {
  1656.                         ERROR("space prohibited after that '$op' $at\n" . $hereptr);
  1657.                     }
  1658.  
  1659.  
  1660.                 # << and >> may either have or not have spaces both sides
  1661.                 } elsif ($op eq '<<' or $op eq '>>' or
  1662.                      $op eq '&' or $op eq '^' or $op eq '|' or
  1663.                      $op eq '+' or $op eq '-' or
  1664.                      $op eq '*' or $op eq '/' or
  1665.                      $op eq '%')
  1666.                 {
  1667.                     if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
  1668.                         ERROR("need consistent spacing around '$op' $at\n" .
  1669.                             $hereptr);
  1670.                     }
  1671.  
  1672.                 # A colon needs no spaces before when it is
  1673.                 # terminating a case value or a label.
  1674.                 } elsif ($opv eq ':C' || $opv eq ':L') {
  1675.                     if ($ctx =~ /Wx./) {
  1676.                         ERROR("space prohibited before that '$op' $at\n" . $hereptr);
  1677.                     }
  1678.  
  1679.                 # All the others need spaces both sides.
  1680.                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
  1681.                     my $ok = 0;
  1682.  
  1683.                     # Ignore email addresses <foo@bar>
  1684.                     if (($op eq '<' &&
  1685.                          $cc =~ /^\S+\@\S+>/) ||
  1686.                         ($op eq '>' &&
  1687.                          $ca =~ /<\S+\@\S+$/))
  1688.                     {
  1689.                             $ok = 1;
  1690.                     }
  1691.  
  1692.                     # Ignore ?:
  1693.                     if (($opv eq ':O' && $ca =~ /\?$/) ||
  1694.                         ($op eq '?' && $cc =~ /^:/)) {
  1695.                             $ok = 1;
  1696.                     }
  1697.  
  1698.                     if ($ok == 0) {
  1699.                         ERROR("spaces required around that '$op' $at\n" . $hereptr);
  1700.                     }
  1701.                 }
  1702.                 $off += length($elements[$n + 1]);
  1703.             }
  1704.         }
  1705.  
  1706. # check for multiple assignments
  1707.         if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
  1708.             CHK("multiple assignments should be avoided\n" . $herecurr);
  1709.         }
  1710.  
  1711. ## # check for multiple declarations, allowing for a function declaration
  1712. ## # continuation.
  1713. ##         if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
  1714. ##             $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
  1715. ##
  1716. ##             # Remove any bracketed sections to ensure we do not
  1717. ##             # falsly report the parameters of functions.
  1718. ##             my $ln = $line;
  1719. ##             while ($ln =~ s/\([^\(\)]*\)//g) {
  1720. ##             }
  1721. ##             if ($ln =~ /,/) {
  1722. ##                 WARN("declaring multiple variables together should be avoided\n" . $herecurr);
  1723. ##             }
  1724. ##         }
  1725.  
  1726. #need space before brace following if, while, etc
  1727.         if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
  1728.             $line =~ /do{/) {
  1729.             ERROR("space required before the open brace '{'\n" . $herecurr);
  1730.         }
  1731.  
  1732. # closing brace should have a space following it when it has anything
  1733. # on the line
  1734.         if ($line =~ /}(?!(?:,|;|\)))\S/) {
  1735.             ERROR("space required after that close brace '}'\n" . $herecurr);
  1736.         }
  1737.  
  1738. # check spacing on square brackets
  1739.         if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
  1740.             ERROR("space prohibited after that open square bracket '['\n" . $herecurr);
  1741.         }
  1742.         if ($line =~ /\s\]/) {
  1743.             ERROR("space prohibited before that close square bracket ']'\n" . $herecurr);
  1744.         }
  1745.  
  1746. # check spacing on parentheses
  1747.         if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
  1748.             $line !~ /for\s*\(\s+;/) {
  1749.             ERROR("space prohibited after that open parenthesis '('\n" . $herecurr);
  1750.         }
  1751.         if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
  1752.             $line !~ /for\s*\(.*;\s+\)/ &&
  1753.             $line !~ /:\s+\)/) {
  1754.             ERROR("space prohibited before that close parenthesis ')'\n" . $herecurr);
  1755.         }
  1756.  
  1757. #goto labels aren't indented, allow a single space however
  1758.         if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
  1759.            !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
  1760.             WARN("labels should not be indented\n" . $herecurr);
  1761.         }
  1762.  
  1763. # Return is not a function.
  1764.         if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
  1765.             my $spacing = $1;
  1766.             my $value = $2;
  1767.  
  1768.             # Flatten any parentheses and braces
  1769.             $value =~ s/\)\(/\) \(/g;
  1770.             while ($value =~ s/\([^\(\)]*\)/1/) {
  1771.             }
  1772.  
  1773.             if ($value =~ /^(?:$Ident|-?$Constant)$/) {
  1774.                 ERROR("return is not a function, parentheses are not required\n" . $herecurr);
  1775.  
  1776.             } elsif ($spacing !~ /\s+/) {
  1777.                 ERROR("space required before the open parenthesis '('\n" . $herecurr);
  1778.             }
  1779.         }
  1780.  
  1781. # Need a space before open parenthesis after if, while etc
  1782.         if ($line=~/\b(if|while|for|switch)\(/) {
  1783.             ERROR("space required before the open parenthesis '('\n" . $herecurr);
  1784.         }
  1785.  
  1786. # Check for illegal assignment in if conditional -- and check for trailing
  1787. # statements after the conditional.
  1788.         if ($line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
  1789.             my ($s, $c) = ($stat, $cond);
  1790.  
  1791.             if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/) {
  1792.                 ERROR("do not use assignment in if condition\n" . $herecurr);
  1793.             }
  1794.  
  1795.             # Find out what is on the end of the line after the
  1796.             # conditional.
  1797.             substr($s, 0, length($c), '');
  1798.             $s =~ s/\n.*//g;
  1799.             $s =~ s/$;//g;     # Remove any comments
  1800.             if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
  1801.                 $c !~ /}\s*while\s*/)
  1802.             {
  1803.                 ERROR("trailing statements should be on next line\n" . $herecurr);
  1804.             }
  1805.         }
  1806.  
  1807. # Check relative indent for conditionals and blocks.
  1808.         if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
  1809.             my ($s, $c) = ($stat, $cond);
  1810.  
  1811.             substr($s, 0, length($c), '');
  1812.  
  1813.             # Make sure we remove the line prefixes as we have
  1814.             # none on the first line, and are going to readd them
  1815.             # where necessary.
  1816.             $s =~ s/\n./\n/gs;
  1817.  
  1818.             # We want to check the first line inside the block
  1819.             # starting at the end of the conditional, so remove:
  1820.             #  1) any blank line termination
  1821.             #  2) any opening brace { on end of the line
  1822.             #  3) any do (...) {
  1823.             my $continuation = 0;
  1824.             my $check = 0;
  1825.             $s =~ s/^.*\bdo\b//;
  1826.             $s =~ s/^\s*{//;
  1827.             if ($s =~ s/^\s*\\//) {
  1828.                 $continuation = 1;
  1829.             }
  1830.             if ($s =~ s/^\s*\n//) {
  1831.                 $check = 1;
  1832.             }
  1833.  
  1834.             # Also ignore a loop construct at the end of a
  1835.             # preprocessor statement.
  1836.             if (($prevline =~ /^.\s*#\s*define\s/ ||
  1837.                 $prevline =~ /\\\s*$/) && $continuation == 0) {
  1838.                 $check = 0;
  1839.             }
  1840.  
  1841.             # Ignore the current line if its is a preprocessor
  1842.             # line.
  1843.             if ($s =~ /^\s*#\s*/) {
  1844.                 $check = 0;
  1845.             }
  1846.  
  1847.             my (undef, $sindent) = line_stats("+" . $s);
  1848.  
  1849.             ##print "line<$line> prevline<$prevline> indent<$indent> sindent<$sindent> check<$check> continuation<$continuation> s<$s>\n";
  1850.  
  1851.             if ($check && (($sindent % 8) != 0 ||
  1852.                 ($sindent <= $indent && $s ne ''))) {
  1853.                 WARN("suspect code indent for conditional statements\n" . $herecurr);
  1854.             }
  1855.         }
  1856.  
  1857. # Check for bitwise tests written as boolean
  1858.         if ($line =~ /
  1859.             (?:
  1860.                 (?:\[|\(|\&\&|\|\|)
  1861.                 \s*0[xX][0-9]+\s*
  1862.                 (?:\&\&|\|\|)
  1863.             |
  1864.                 (?:\&\&|\|\|)
  1865.                 \s*0[xX][0-9]+\s*
  1866.                 (?:\&\&|\|\||\)|\])
  1867.             )/x)
  1868.         {
  1869.             WARN("boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
  1870.         }
  1871.  
  1872. # if and else should not have general statements after it
  1873.         if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
  1874.             my $s = $1;
  1875.             $s =~ s/$;//g;     # Remove any comments
  1876.             if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
  1877.                 ERROR("trailing statements should be on next line\n" . $herecurr);
  1878.             }
  1879.         }
  1880.  
  1881.         # Check for }<nl>else {, these must be at the same
  1882.         # indent level to be relevant to each other.
  1883.         if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
  1884.                         $previndent == $indent) {
  1885.             ERROR("else should follow close brace '}'\n" . $hereprev);
  1886.         }
  1887.  
  1888.         if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
  1889.                         $previndent == $indent) {
  1890.             my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
  1891.  
  1892.             # Find out what is on the end of the line after the
  1893.             # conditional.
  1894.             substr($s, 0, length($c), '');
  1895.             $s =~ s/\n.*//g;
  1896.  
  1897.             if ($s =~ /^\s*;/) {
  1898.                 ERROR("while should follow close brace '}'\n" . $hereprev);
  1899.             }
  1900.         }
  1901.  
  1902. #studly caps, commented out until figure out how to distinguish between use of existing and adding new
  1903. #        if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
  1904. #            print "No studly caps, use _\n";
  1905. #            print "$herecurr";
  1906. #            $clean = 0;
  1907. #        }
  1908.  
  1909. #no spaces allowed after \ in define
  1910.         if ($line=~/\#\s*define.*\\\s$/) {
  1911.             WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);
  1912.         }
  1913.  
  1914. #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
  1915.         if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
  1916.             my $checkfile = "include/linux/$1.h";
  1917.             if (-f "$root/$checkfile" && $realfile ne $checkfile &&
  1918.                 $1 ne 'irq')
  1919.             {
  1920.                 WARN("Use #include <linux/$1.h> instead of <asm/$1.h>\n" .
  1921.                     $herecurr);
  1922.             }
  1923.         }
  1924.  
  1925. # multi-statement macros should be enclosed in a do while loop, grab the
  1926. # first statement and ensure its the whole macro if its not enclosed
  1927. # in a known good container
  1928.         if ($realfile !~ m@/vmlinux.lds.h$@ &&
  1929.             $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
  1930.             my $ln = $linenr;
  1931.             my $cnt = $realcnt;
  1932.             my ($off, $dstat, $dcond, $rest);
  1933.             my $ctx = '';
  1934.  
  1935.             my $args = defined($1);
  1936.  
  1937.             # Find the end of the macro and limit our statement
  1938.             # search to that.
  1939.             while ($cnt > 0 && defined $lines[$ln - 1] &&
  1940.                 $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
  1941.             {
  1942.                 $ctx .= $rawlines[$ln - 1] . "\n";
  1943.                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
  1944.                 $ln++;
  1945.             }
  1946.             $ctx .= $rawlines[$ln - 1];
  1947.  
  1948.             ($dstat, $dcond, $ln, $cnt, $off) =
  1949.                 ctx_statement_block($linenr, $ln - $linenr + 1, 0);
  1950.             #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
  1951.             #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
  1952.  
  1953.             # Extract the remainder of the define (if any) and
  1954.             # rip off surrounding spaces, and trailing \'s.
  1955.             $rest = '';
  1956.             while ($off != 0 || ($cnt > 0 && $rest =~ /(?:^|\\)\s*$/)) {
  1957.                 #print "ADDING $off <" . substr($lines[$ln - 1], $off) . ">\n";
  1958.                 if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
  1959.                     $rest .= substr($lines[$ln - 1], $off) . "\n";
  1960.                     $cnt--;
  1961.                 }
  1962.                 $ln++;
  1963.                 $off = 0;
  1964.             }
  1965.             $rest =~ s/\\\n.//g;
  1966.             $rest =~ s/^\s*//s;
  1967.             $rest =~ s/\s*$//s;
  1968.  
  1969.             # Clean up the original statement.
  1970.             if ($args) {
  1971.                 substr($dstat, 0, length($dcond), '');
  1972.             } else {
  1973.                 $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
  1974.             }
  1975.             $dstat =~ s/$;//g;
  1976.             $dstat =~ s/\\\n.//g;
  1977.             $dstat =~ s/^\s*//s;
  1978.             $dstat =~ s/\s*$//s;
  1979.  
  1980.             # Flatten any parentheses and braces
  1981.             while ($dstat =~ s/\([^\(\)]*\)/1/) {
  1982.             }
  1983.             while ($dstat =~ s/\{[^\{\}]*\}/1/) {
  1984.             }
  1985.  
  1986.             my $exceptions = qr{
  1987.                 $Declare|
  1988.                 module_param_named|
  1989.                 MODULE_PARAM_DESC|
  1990.                 DECLARE_PER_CPU|
  1991.                 DEFINE_PER_CPU|
  1992.                 __typeof__\(
  1993.             }x;
  1994.             #print "REST<$rest>\n";
  1995.             if ($rest ne '') {
  1996.                 if ($rest !~ /while\s*\(/ &&
  1997.                     $dstat !~ /$exceptions/)
  1998.                 {
  1999.                     ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
  2000.                 }
  2001.  
  2002.             } elsif ($ctx !~ /;/) {
  2003.                 if ($dstat ne '' &&
  2004.                     $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
  2005.                     $dstat !~ /$exceptions/ &&
  2006.                     $dstat =~ /$Operators/)
  2007.                 {
  2008.                     ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
  2009.                 }
  2010.             }
  2011.         }
  2012.  
  2013. # check for redundant bracing round if etc
  2014.         if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
  2015.             my ($level, $endln, @chunks) =
  2016.                 ctx_statement_full($linenr, $realcnt, 1);
  2017.             #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
  2018.             #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
  2019.             if ($#chunks > 0 && $level == 0) {
  2020.                 my $allowed = 0;
  2021.                 my $seen = 0;
  2022.                 my $herectx = $here . "\n";
  2023.                 my $ln = $linenr - 1;
  2024.                 for my $chunk (@chunks) {
  2025.                     my ($cond, $block) = @{$chunk};
  2026.  
  2027.                     # If the condition carries leading newlines, then count those as offsets.
  2028.                     my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
  2029.                     my $offset = statement_rawlines($whitespace) - 1;
  2030.  
  2031.                     #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
  2032.  
  2033.                     # We have looked at and allowed this specific line.
  2034.                     $suppress_ifbraces{$ln + $offset} = 1;
  2035.  
  2036.                     $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
  2037.                     $ln += statement_rawlines($block) - 1;
  2038.  
  2039.                     substr($block, 0, length($cond), '');
  2040.  
  2041.                     $seen++ if ($block =~ /^\s*{/);
  2042.  
  2043.                     #print "cond<$cond> block<$block> allowed<$allowed>\n";
  2044.                     if (statement_lines($cond) > 1) {
  2045.                         #print "APW: ALLOWED: cond<$cond>\n";
  2046.                         $allowed = 1;
  2047.                     }
  2048.                     if ($block =~/\b(?:if|for|while)\b/) {
  2049.                         #print "APW: ALLOWED: block<$block>\n";
  2050.                         $allowed = 1;
  2051.                     }
  2052.                     if (statement_block_size($block) > 1) {
  2053.                         #print "APW: ALLOWED: lines block<$block>\n";
  2054.                         $allowed = 1;
  2055.                     }
  2056.                 }
  2057.                 if ($seen && !$allowed) {
  2058.                     WARN("braces {} are not necessary for any arm of this statement\n" . $herectx);
  2059.                 }
  2060.             }
  2061.         }
  2062.         if (!defined $suppress_ifbraces{$linenr - 1} &&
  2063.                     $line =~ /\b(if|while|for|else)\b/) {
  2064.             my $allowed = 0;
  2065.  
  2066.             # Check the pre-context.
  2067.             if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
  2068.                 #print "APW: ALLOWED: pre<$1>\n";
  2069.                 $allowed = 1;
  2070.             }
  2071.  
  2072.             my ($level, $endln, @chunks) =
  2073.                 ctx_statement_full($linenr, $realcnt, $-[0]);
  2074.  
  2075.             # Check the condition.
  2076.             my ($cond, $block) = @{$chunks[0]};
  2077.             #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
  2078.             if (defined $cond) {
  2079.                 substr($block, 0, length($cond), '');
  2080.             }
  2081.             if (statement_lines($cond) > 1) {
  2082.                 #print "APW: ALLOWED: cond<$cond>\n";
  2083.                 $allowed = 1;
  2084.             }
  2085.             if ($block =~/\b(?:if|for|while)\b/) {
  2086.                 #print "APW: ALLOWED: block<$block>\n";
  2087.                 $allowed = 1;
  2088.             }
  2089.             if (statement_block_size($block) > 1) {
  2090.                 #print "APW: ALLOWED: lines block<$block>\n";
  2091.                 $allowed = 1;
  2092.             }
  2093.             # Check the post-context.
  2094.             if (defined $chunks[1]) {
  2095.                 my ($cond, $block) = @{$chunks[1]};
  2096.                 if (defined $cond) {
  2097.                     substr($block, 0, length($cond), '');
  2098.                 }
  2099.                 if ($block =~ /^\s*\{/) {
  2100.                     #print "APW: ALLOWED: chunk-1 block<$block>\n";
  2101.                     $allowed = 1;
  2102.                 }
  2103.             }
  2104.             if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
  2105.                 my $herectx = $here . "\n";;
  2106.                 my $end = $linenr + statement_rawlines($block) - 1;
  2107.  
  2108.                 for (my $ln = $linenr - 1; $ln < $end; $ln++) {
  2109.                     $herectx .= $rawlines[$ln] . "\n";;
  2110.                 }
  2111.  
  2112.                 WARN("braces {} are not necessary for single statement blocks\n" . $herectx);
  2113.             }
  2114.         }
  2115.  
  2116. # don't include deprecated include files (uses RAW line)
  2117.         for my $inc (@dep_includes) {
  2118.             if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) {
  2119.                 ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
  2120.             }
  2121.         }
  2122.  
  2123. # don't use deprecated functions
  2124.         for my $func (@dep_functions) {
  2125.             if ($line =~ /\b$func\b/) {
  2126.                 ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
  2127.             }
  2128.         }
  2129.  
  2130. # no volatiles please
  2131.         my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
  2132.         if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
  2133.             WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
  2134.         }
  2135.  
  2136. # SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated
  2137.         if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {
  2138.             ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);
  2139.         }
  2140.  
  2141. # warn about #if 0
  2142.         if ($line =~ /^.\s*\#\s*if\s+0\b/) {
  2143.             CHK("if this code is redundant consider removing it\n" .
  2144.                 $herecurr);
  2145.         }
  2146.  
  2147. # check for needless kfree() checks
  2148.         if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
  2149.             my $expr = $1;
  2150.             if ($line =~ /\bkfree\(\Q$expr\E\);/) {
  2151.                 WARN("kfree(NULL) is safe this check is probably not required\n" . $hereprev);
  2152.             }
  2153.         }
  2154. # check for needless usb_free_urb() checks
  2155.         if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
  2156.             my $expr = $1;
  2157.             if ($line =~ /\busb_free_urb\(\Q$expr\E\);/) {
  2158.                 WARN("usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);
  2159.             }
  2160.         }
  2161.  
  2162. # warn about #ifdefs in C files
  2163. #        if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
  2164. #            print "#ifdef in C files should be avoided\n";
  2165. #            print "$herecurr";
  2166. #            $clean = 0;
  2167. #        }
  2168.  
  2169. # warn about spacing in #ifdefs
  2170.         if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
  2171.             ERROR("exactly one space required after that #$1\n" . $herecurr);
  2172.         }
  2173.  
  2174. # check for spinlock_t definitions without a comment.
  2175.         if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
  2176.             $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
  2177.             my $which = $1;
  2178.             if (!ctx_has_comment($first_line, $linenr)) {
  2179.                 CHK("$1 definition without comment\n" . $herecurr);
  2180.             }
  2181.         }
  2182. # check for memory barriers without a comment.
  2183.         if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
  2184.             if (!ctx_has_comment($first_line, $linenr)) {
  2185.                 CHK("memory barrier without comment\n" . $herecurr);
  2186.             }
  2187.         }
  2188. # check of hardware specific defines
  2189.         if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
  2190.             CHK("architecture specific defines should be avoided\n" .  $herecurr);
  2191.         }
  2192.  
  2193. # check the location of the inline attribute, that it is between
  2194. # storage class and type.
  2195.         if ($line =~ /\b$Type\s+$Inline\b/ ||
  2196.             $line =~ /\b$Inline\s+$Storage\b/) {
  2197.             ERROR("inline keyword should sit between storage class and type\n" . $herecurr);
  2198.         }
  2199.  
  2200. # Check for __inline__ and __inline, prefer inline
  2201.         if ($line =~ /\b(__inline__|__inline)\b/) {
  2202.             WARN("plain inline is preferred over $1\n" . $herecurr);
  2203.         }
  2204.  
  2205. # check for new externs in .c files.
  2206.         if ($realfile =~ /\.c$/ && defined $stat &&
  2207.             $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
  2208.         {
  2209.             my $function_name = $1;
  2210.             my $paren_space = $2;
  2211.  
  2212.             my $s = $stat;
  2213.             if (defined $cond) {
  2214.                 substr($s, 0, length($cond), '');
  2215.             }
  2216.             if ($s =~ /^\s*;/ &&
  2217.                 $function_name ne 'uninitialized_var')
  2218.             {
  2219.                 WARN("externs should be avoided in .c files\n" .  $herecurr);
  2220.             }
  2221.  
  2222.             if ($paren_space =~ /\n/) {
  2223.                 WARN("arguments for function declarations should follow identifier\n" . $herecurr);
  2224.             }
  2225.  
  2226.         } elsif ($realfile =~ /\.c$/ && defined $stat &&
  2227.             $stat =~ /^.\s*extern\s+/)
  2228.         {
  2229.             WARN("externs should be avoided in .c files\n" .  $herecurr);
  2230.         }
  2231.  
  2232. # checks for new __setup's
  2233.         if ($rawline =~ /\b__setup\("([^"]*)"/) {
  2234.             my $name = $1;
  2235.  
  2236.             if (!grep(/$name/, @setup_docs)) {
  2237.                 CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
  2238.             }
  2239.         }
  2240.  
  2241. # check for pointless casting of kmalloc return
  2242.         if ($line =~ /\*\s*\)\s*k[czm]alloc\b/) {
  2243.             WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
  2244.         }
  2245.  
  2246. # check for gcc specific __FUNCTION__
  2247.         if ($line =~ /__FUNCTION__/) {
  2248.             WARN("__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr);
  2249.         }
  2250.  
  2251. # check for semaphores used as mutexes
  2252.         if ($line =~ /^.\s*(DECLARE_MUTEX|init_MUTEX)\s*\(/) {
  2253.             WARN("mutexes are preferred for single holder semaphores\n" . $herecurr);
  2254.         }
  2255. # check for semaphores used as mutexes
  2256.         if ($line =~ /^.\s*init_MUTEX_LOCKED\s*\(/) {
  2257.             WARN("consider using a completion\n" . $herecurr);
  2258.         }
  2259. # recommend strict_strto* over simple_strto*
  2260.         if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
  2261.             WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr);
  2262.         }
  2263. # check for __initcall(), use device_initcall() explicitly please
  2264.         if ($line =~ /^.\s*__initcall\s*\(/) {
  2265.             WARN("please use device_initcall() instead of __initcall()\n" . $herecurr);
  2266.         }
  2267.  
  2268. # use of NR_CPUS is usually wrong
  2269. # ignore definitions of NR_CPUS and usage to define arrays as likely right
  2270.         if ($line =~ /\bNR_CPUS\b/ &&
  2271.             $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
  2272.             $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
  2273.             $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
  2274.             $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
  2275.             $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
  2276.         {
  2277.             WARN("usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
  2278.         }
  2279.  
  2280. # check for %L{u,d,i} in strings
  2281.         my $string;
  2282.         while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
  2283.             $string = substr($rawline, $-[1], $+[1] - $-[1]);
  2284.             if ($string =~ /(?<!%)%L[udi]/) {
  2285.                 WARN("\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
  2286.                 last;
  2287.             }
  2288.         }
  2289.     }
  2290.  
  2291.     # If we have no input at all, then there is nothing to report on
  2292.     # so just keep quiet.
  2293.     if ($#rawlines == -1) {
  2294.         exit(0);
  2295.     }
  2296.  
  2297.     # In mailback mode only produce a report in the negative, for
  2298.     # things that appear to be patches.
  2299.     if ($mailback && ($clean == 1 || !$is_patch)) {
  2300.         exit(0);
  2301.     }
  2302.  
  2303.     # This is not a patch, and we are are in 'no-patch' mode so
  2304.     # just keep quiet.
  2305.     if (!$chk_patch && !$is_patch) {
  2306.         exit(0);
  2307.     }
  2308.  
  2309.     if (!$is_patch) {
  2310.         ERROR("Does not appear to be a unified-diff format patch\n");
  2311.     }
  2312.     if ($is_patch && $chk_signoff && $signoff == 0) {
  2313.         ERROR("Missing Signed-off-by: line(s)\n");
  2314.     }
  2315.  
  2316.     print report_dump();
  2317.     if ($summary && !($clean == 1 && $quiet == 1)) {
  2318.         print "$filename " if ($summary_file);
  2319.         print "total: $cnt_error errors, $cnt_warn warnings, " .
  2320.             (($check)? "$cnt_chk checks, " : "") .
  2321.             "$cnt_lines lines checked\n";
  2322.         print "\n" if ($quiet == 0);
  2323.     }
  2324.  
  2325.     if ($clean == 1 && $quiet == 0) {
  2326.         print "$vname has no obvious style problems and is ready for submission.\n"
  2327.     }
  2328.     if ($clean == 0 && $quiet == 0) {
  2329.         print "$vname has style problems, please review.  If any of these errors\n";
  2330.         print "are false positives report them to the maintainer, see\n";
  2331.         print "CHECKPATCH in MAINTAINERS.\n";
  2332.     }
  2333.  
  2334.     return $clean;
  2335. }
  2336.